home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 22 / Cream of the Crop 22.iso / program / ctlib100.zip / INSTALL.LZH / CTARRAYS.INT < prev    next >
Text File  |  1996-10-12  |  14KB  |  380 lines
  1. {**************************************************************************}
  2. {*  BitSoft Development, L.L.C.                                           *}
  3. {*  Copyright (C) 1995, 1996 BitSoft Development, L.L.C.                  *}
  4. {*  All rights reserved.                                                  *}
  5. {*  Array objects unit                                                    *}
  6. {*  Version 1.4.5                                                         *}
  7. {**************************************************************************}
  8.  
  9. unit ctArrays;
  10.  
  11. {$X+,B-}
  12.  
  13. interface
  14.  
  15. uses Objects,
  16.      {$ifdef ver60} BsdVer60, {$endif}
  17.      Containr, ctTypes;
  18.  
  19. type
  20.   PDynamicArray = ^TDynamicArray;
  21.   TDynamicArray = object(TSequence)
  22.       DataSize : Word;
  23.     constructor Init(Start, Stop : LongInt; ADataSize : Word);
  24.     constructor Load(var S: TStream);
  25.     function AtClear(Index : LongInt): Boolean; virtual;
  26.     function FreeAll : Boolean; virtual;
  27.     function IndexOf(Item : Pointer) : LongInt; virtual;
  28.     procedure Store(var S: TStream);
  29.   end; { TDynamicArray }
  30.  
  31. type
  32.   PMemArray = ^TMemArray;
  33.   TMemArray = object(TDynamicArray)
  34.     function AtFree (Index : LongInt) : Boolean; virtual;
  35.     function AtReplace(Index : LongInt; Item : Pointer) : Boolean; virtual;
  36.     function Free (Item : Pointer) : Boolean; virtual;
  37.     procedure FreeItem (Item : Pointer); virtual;
  38.     function GetItem (var S: TStream) : Pointer; virtual;
  39.     procedure PutItem (var S: TStream; Item : Pointer); virtual;
  40.   end; { TMemArray }
  41.  
  42. type
  43.   PStdArray = ^TStdArray;
  44.   TStdArray = object(TMemArray)
  45.       Data : PChar;
  46.     constructor Init (Start, Stop : LongInt; ADataSize : Word);
  47.     constructor Load (var S: TStream);
  48.     destructor Done; virtual;
  49.     function At(Index : LongInt): Pointer; virtual;
  50.     function AtDelete(Index : LongInt): Boolean; virtual;
  51.     function AtInsert(Index : LongInt; Item : Pointer): Boolean; virtual;
  52.     function AtPut(Index: LongInt; Item : Pointer) : Boolean; virtual;
  53.     function DeleteAll: Boolean; virtual;
  54.     procedure Store (var S: TStream);
  55.   end; { TStdArray }
  56.  
  57. type
  58.   PResizableStdArray = ^TResizableStdArray;
  59.   TResizableStdArray = object(TStdArray)
  60.       Limit : Word;
  61.       Delta : Word;
  62.     constructor Init(ALimit, ADelta, ADataSize : Word);
  63.     constructor Load(var S: TStream);
  64.     destructor Done; virtual;
  65.     function AtDelete(Index : LongInt): Boolean; virtual;
  66.     function AtInsert(Index : LongInt; Item : Pointer): Boolean; virtual;
  67.     function DeleteAll: Boolean; virtual;
  68.     function SetLimit(ALimit : Word): Boolean;
  69.     procedure Store(var S: TStream);
  70.   end; { TResizableStdArray }
  71.  
  72. type
  73.   PSortedStdArray = ^TSortedStdArray;
  74.   TSortedStdArray = object(TResizableStdArray)
  75.       Duplicates : Boolean;
  76.       CaseSensitive : Boolean;
  77.     constructor Init(ALimit, ADelta, ADataSize : Word);
  78.     constructor Load (var S: TStream);
  79.     function Compare(Key1, Key2 : Pointer): Integer; virtual;
  80.     function IndexOf (Item : Pointer) : LongInt; virtual;
  81.     function Insert(Item : Pointer) : Boolean; virtual;
  82.     function KeyOf (Item : Pointer) : Pointer; virtual;
  83.     function Search (Key : Pointer; var Index : LongInt) : Boolean; virtual;
  84.     procedure Store (var S: TStream);
  85.   end; { TSortedStdArray }
  86.  
  87. type
  88.   PStdObjectArray = ^TStdObjectArray;
  89.   TStdObjectArray = object(TStdArray)
  90.     procedure FreeItem (Item : Pointer); virtual;
  91.     function GetItem (var S : TStream) : Pointer; virtual;
  92.     function IsValidObject(Item : Pointer): Boolean; virtual;
  93.     procedure PutItem (var S : TStream; Item : Pointer); virtual;
  94.   end; { TStdObjectArray }
  95.  
  96. type
  97.   PResizableStdObjectArray = ^TResizableStdObjectArray;
  98.   TResizableStdObjectArray = object(TResizableStdArray)
  99.     procedure FreeItem (Item : Pointer); virtual;
  100.     function GetItem (var S : TStream) : Pointer; virtual;
  101.     function IsValidObject(Item : Pointer): Boolean; virtual;
  102.     procedure PutItem (var S : TStream; Item : Pointer); virtual;
  103.   end; { TResizableStdObjectArray }
  104.  
  105. type
  106.   PSortedStdObjectArray = ^TSortedStdObjectArray;
  107.   TSortedStdObjectArray = object(TSortedStdArray)
  108.     procedure FreeItem (Item : Pointer); virtual;
  109.     function GetItem (var S : TStream) : Pointer; virtual;
  110.     function IsValidObject(Item : Pointer): Boolean; virtual;
  111.     procedure PutItem (var S : TStream; Item : Pointer); virtual;
  112.   end; { TSortedStdObjectArray }
  113.  
  114. type
  115.   PArrayList = ^TArrayList;
  116.   TArrayList = array[0..Pred(MaxCollectionSize)] of PChar;
  117.  
  118. type
  119.   PHugeArray = ^THugeArray;
  120.   THugeArray = object(TMemArray)
  121.       Data : PArrayList;
  122.       MaxArraySize : Word;
  123.     constructor Init (Start, Stop : LongInt; ADataSize : Word);
  124.     constructor Load (var S: TStream);
  125.     destructor Done; virtual;
  126.     function AllocateArray : Boolean;
  127.     function At(Index : LongInt): Pointer; virtual;
  128.     function AtDelete(Index : LongInt): Boolean; virtual;
  129.     function AtInsert(Index : LongInt; Item : Pointer): Boolean; virtual;
  130.     function AtPut(Index: LongInt; Item : Pointer) : Boolean; virtual;
  131.     function DeleteAll: Boolean; virtual;
  132.     procedure Store (var S: TStream);
  133.   end; { THugeArray }
  134.  
  135. type
  136.   PResizableHugeArray = ^TResizableHugeArray;
  137.   TResizableHugeArray = object(THugeArray)
  138.       Limit : LongInt;
  139.       Delta : LongInt;
  140.     constructor Init(ALimit, ADelta : LongInt; ADataSize : Word);
  141.     constructor Load(var S: TStream);
  142.     destructor Done; virtual;
  143.     function AtDelete(Index : LongInt): Boolean; virtual;
  144.     function AtInsert(Index : LongInt; Item : Pointer): Boolean; virtual;
  145.     function DeleteAll: Boolean; virtual;
  146.     function SetLimit(ALimit : LongInt): Boolean;
  147.     procedure Store(var S: TStream);
  148.   end; { TResizableHugeArray }
  149.  
  150. type
  151.   PSortedHugeArray = ^TSortedHugeArray;
  152.   TSortedHugeArray = object(TResizableHugeArray)
  153.       Duplicates : Boolean;
  154.       CaseSensitive : Boolean;
  155.     constructor Init(ALimit, ADelta : LongInt; ADataSize : Word);
  156.     constructor Load (var S: TStream);
  157.     function Compare(Key1, Key2 : Pointer): Integer; virtual;
  158.     function IndexOf (Item : Pointer) : LongInt; virtual;
  159.     function Insert(Item : Pointer) : Boolean; virtual;
  160.     function KeyOf (Item : Pointer) : Pointer; virtual;
  161.     function Search (Key : Pointer; var Index : LongInt) : Boolean; virtual;
  162.     procedure Store (var S: TStream);
  163.   end; { TSortedHugeArray }
  164.  
  165. type
  166.   PHugeObjectArray = ^THugeObjectArray;
  167.   THugeObjectArray = object(THugeArray)
  168.     procedure FreeItem (Item : Pointer); virtual;
  169.     function GetItem (var S : TStream) : Pointer; virtual;
  170.     function IsValidObject(Item : Pointer): Boolean; virtual;
  171.     procedure PutItem (var S : TStream; Item : Pointer); virtual;
  172.   end; { THugeObjectArray }
  173.  
  174. type
  175.   PResizableHugeObjectArray = ^TResizableHugeObjectArray;
  176.   TResizableHugeObjectArray = object(TResizableHugeArray)
  177.     procedure FreeItem (Item : Pointer); virtual;
  178.     function GetItem (var S : TStream) : Pointer; virtual;
  179.     function IsValidObject(Item : Pointer): Boolean; virtual;
  180.     procedure PutItem (var S : TStream; Item : Pointer); virtual;
  181.   end; { TResizableHugeObjectArray }
  182.  
  183. type
  184.   PSortedHugeObjectArray = ^TSortedHugeObjectArray;
  185.   TSortedHugeObjectArray = object(TSortedHugeArray)
  186.     procedure FreeItem (Item : Pointer); virtual;
  187.     function GetItem (var S : TStream) : Pointer; virtual;
  188.     function IsValidObject(Item : Pointer): Boolean; virtual;
  189.     procedure PutItem (var S : TStream; Item : Pointer); virtual;
  190.   end; { TSortedHugeObjectArray }
  191.  
  192. type
  193.   PStreamArray = ^TStreamArray;
  194.   TStreamArray = object (TDynamicArray)
  195.       Stream : PStream;
  196.     constructor Init(Start, Stop : LongInt; ADataSize, AElementSize : Word);
  197.     constructor Load(var S: TStream);
  198.     destructor Done; virtual;
  199.     function AtDelete(Index : LongInt): Boolean; virtual;
  200.     function AtInsert(Index : LongInt; Item : Pointer): Boolean; virtual;
  201.     function DeleteAll: Boolean; virtual;
  202.     procedure DoneItem(Item : Pointer); virtual;
  203.     function ForEach (Action : Pointer) : Boolean; virtual;
  204.     function ForEachThat (Test, Action : Pointer) : Boolean; virtual;
  205.     function InitStream (Size : LongInt) : PStream; virtual;
  206.     procedure Reset; virtual;
  207.     procedure Store(var S: TStream);
  208.   private
  209.       ElementSize : Word;
  210.   end; { TStreamArray }
  211.  
  212. type
  213.   PStreamStdArray = ^TStreamStdArray;
  214.   TStreamStdArray = object(TStreamArray)
  215.     constructor Init(Start, Stop : LongInt; ADataSize : Word);
  216.     constructor Load(var S: TStream);
  217.     function At (Index : LongInt) : Pointer; virtual;
  218.     function AtPut (Index : LongInt; Item : Pointer): Boolean; virtual;
  219.     procedure FreeItem(Item : Pointer); virtual;
  220.     function GetItem(var S: TStream): Pointer; virtual;
  221.     procedure PutItem(var S: TStream; Item : Pointer); virtual;
  222.     function ReadItem: Pointer; virtual;
  223.     procedure Store(var S: TStream);
  224.     procedure WriteItem(Item: Pointer); virtual;
  225.   end; { TStreamStdArray }
  226.  
  227. type
  228.   PEmsStdArray = ^TEmsStdArray;
  229.   TEmsStdArray = object(TStreamStdArray)
  230.     function InitStream(Size: LongInt): PStream;  virtual;
  231.   end; { TEmsStdArray }
  232.  
  233. type
  234.   PStreamStdObjectArray = ^TStreamStdObjectArray;
  235.   TStreamStdObjectArray = object(TStreamStdArray)
  236.     procedure DoneItem(Item : Pointer); virtual;
  237.     procedure FreeItem (Item : Pointer); virtual;
  238.     function GetItem (var S : TStream) : Pointer; virtual;
  239.     procedure PutItem (var S : TStream; Item : Pointer); virtual;
  240.     function ReadItem: Pointer; virtual;
  241.     procedure WriteItem(Item: Pointer); virtual;
  242.   end; { TStreamStdObjectArray }
  243.  
  244. type
  245.   PEmsStdObjectArray = ^TEmsStdObjectArray;
  246.   TEmsStdObjectArray = object(TStreamStdObjectArray)
  247.     function InitStream(Size: LongInt): PStream;  virtual;
  248.   end; { TEmsStdObjectArray }
  249.  
  250. type
  251.   PStreamObjectArray = ^TStreamObjectArray;
  252.   TStreamObjectArray = object(TStreamArray)
  253.     constructor Init(Start, Stop : LongInt; ADataSize : Word);
  254.     constructor Load(var S: TStream);
  255.     function At(Index : LongInt) : Pointer; virtual;
  256.     function AtPut(Index : LongInt; Item : Pointer): Boolean; virtual;
  257.     function FreeAll: Boolean; virtual;
  258.     procedure Store(var S: TStream);
  259.   end; { TStreamObjectArray }
  260.  
  261. type
  262.   PEmsObjectArray = ^TEmsObjectArray;
  263.   TEmsObjectArray = object(TStreamObjectArray)
  264.     function InitStream(Size: LongInt): PStream;  virtual;
  265.   end; { TEmsObjectArray }
  266.  
  267. procedure RegisterArrays;
  268.  
  269. const
  270.   RStdArray: TStreamRec = (
  271.     ObjType: idStdArray;
  272.     VmtLink: Ofs(TypeOf(TStdArray)^);
  273.     Load:    @TStdArray.Load;
  274.     Store:   @TStdArray.Store);
  275.  
  276.   RResizableStdArray: TStreamRec = (
  277.     ObjType: idResizableStdArray;
  278.     VmtLink: Ofs(TypeOf(TResizableStdArray)^);
  279.     Load:    @TResizableStdArray.Load;
  280.     Store:   @TResizableStdArray.Store);
  281.  
  282.   RSortedStdArray: TStreamRec = (
  283.     ObjType: idSortedStdArray;
  284.     VmtLink: Ofs(TypeOf(TSortedStdArray)^);
  285.     Load:    @TSortedStdArray.Load;
  286.     Store:   @TSortedStdArray.Store);
  287.  
  288.   RStdObjectArray: TStreamRec = (
  289.     ObjType: idStdObjectArray;
  290.     VmtLink: Ofs(TypeOf(TStdObjectArray)^);
  291.     Load:    @TStdObjectArray.Load;
  292.     Store:   @TStdObjectArray.Store);
  293.  
  294.   RResizableStdObjectArray: TStreamRec = (
  295.     ObjType: idResizableStdObjectArray;
  296.     VmtLink: Ofs(TypeOf(TResizableStdObjectArray)^);
  297.     Load:    @TResizableStdObjectArray.Load;
  298.     Store:   @TResizableStdObjectArray.Store);
  299.  
  300.   RSortedStdObjectArray: TStreamRec = (
  301.     ObjType: idSortedStdObjectArray;
  302.     VmtLink: Ofs(TypeOf(TSortedStdObjectArray)^);
  303.     Load:    @TSortedStdObjectArray.Load;
  304.     Store:   @TSortedStdObjectArray.Store);
  305.  
  306.   RHugeArray: TStreamRec = (
  307.     ObjType: idHugeArray;
  308.     VmtLink: Ofs(TypeOf(THugeArray)^);
  309.     Load:    @THugeArray.Load;
  310.     Store:   @THugeArray.Store);
  311.  
  312.   RResizableHugeArray: TStreamRec = (
  313.     ObjType: idResizableHugeArray;
  314.     VmtLink: Ofs(TypeOf(TResizableHugeArray)^);
  315.     Load:    @TResizableHugeArray.Load;
  316.     Store:   @TResizableHugeArray.Store);
  317.  
  318.   RSortedHugeArray: TStreamRec = (
  319.     ObjType: idSortedHugeArray;
  320.     VmtLink: Ofs(TypeOf(TSortedHugeArray)^);
  321.     Load:    @TSortedHugeArray.Load;
  322.     Store:   @TSortedHugeArray.Store);
  323.  
  324.   RHugeObjectArray: TStreamRec = (
  325.     ObjType: idHugeObjectArray;
  326.     VmtLink: Ofs(TypeOf(THugeObjectArray)^);
  327.     Load:    @THugeObjectArray.Load;
  328.     Store:   @THugeObjectArray.Store);
  329.  
  330.   RResizableHugeObjectArray: TStreamRec = (
  331.     ObjType: idResizableHugeObjectArray;
  332.     VmtLink: Ofs(TypeOf(TResizableHugeObjectArray)^);
  333.     Load:    @TResizableHugeObjectArray.Load;
  334.     Store:   @TResizableHugeObjectArray.Store);
  335.  
  336.   RSortedHugeObjectArray: TStreamRec = (
  337.     ObjType: idSortedHugeObjectArray;
  338.     VmtLink: Ofs(TypeOf(TSortedHugeObjectArray)^);
  339.     Load:    @TSortedHugeObjectArray.Load;
  340.     Store:   @TSortedHugeObjectArray.Store);
  341.  
  342.   RStreamStdArray: TStreamRec = (
  343.     ObjType: idStreamStdArray;
  344.     VmtLink: Ofs(TypeOf(TStreamStdArray)^);
  345.     Load:    @TStreamStdArray.Load;
  346.     Store:   @TStreamStdArray.Store);
  347.  
  348.   REmsStdArray: TStreamRec = (
  349.     ObjType: idEmsStdArray;
  350.     VmtLink: Ofs(TypeOf(TEmsStdArray)^);
  351.     Load:    @TEmsStdArray.Load;
  352.     Store:   @TEmsStdArray.Store);
  353.  
  354.   RStreamStdObjectArray: TStreamRec = (
  355.     ObjType: idStreamStdObjectArray;
  356.     VmtLink: Ofs(TypeOf(TStreamStdObjectArray)^);
  357.     Load:    @TStreamStdObjectArray.Load;
  358.     Store:   @TStreamStdObjectArray.Store);
  359.  
  360.   REmsStdObjectArray: TStreamRec = (
  361.     ObjType: idEmsStdObjectArray;
  362.     VmtLink: Ofs(TypeOf(TEmsStdObjectArray)^);
  363.     Load:    @TEmsStdObjectArray.Load;
  364.     Store:   @TEmsStdObjectArray.Store);
  365.  
  366.   RStreamObjectArray: TStreamRec = (
  367.     ObjType: idStreamObjectArray;
  368.     VmtLink: Ofs(TypeOf(TStreamObjectArray)^);
  369.     Load:    @TStreamObjectArray.Load;
  370.     Store:   @TStreamObjectArray.Store);
  371.  
  372.   REmsObjectArray: TStreamRec = (
  373.     ObjType: idEmsObjectArray;
  374.     VmtLink: Ofs(TypeOf(TEmsObjectArray)^);
  375.     Load:    @TEmsObjectArray.Load;
  376.     Store:   @TEmsObjectArray.Store);
  377.  
  378. implementation
  379. end.
  380.